home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / libol / io.h < prev    next >
Encoding:
C/C++ Source or Header  |  2005-10-16  |  7.3 KB  |  292 lines
  1. /***************************************************************************
  2.  *
  3.  * Copyright (c) 1998-1999 Niels M÷ller
  4.  * Copyright (c) 1999 BalaBit Computing
  5.  * 
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * $Id: io.h,v 1.11 2001/08/26 21:28:18 bazsi Exp $
  21.  *
  22.  ***************************************************************************/
  23.  
  24. #ifndef __IO_H_INCLUDED
  25. #define __IO_H_INCLUDED
  26.  
  27. #include "abstract_io.h"
  28. #include "resource.h"
  29. #include "queue.h"
  30.  
  31. #include <time.h>
  32. #include <netdb.h>
  33. #include <sys/types.h>
  34. #include <sys/socket.h>
  35. #include <netinet/in.h>
  36.  
  37. #define CLASS_DECLARE
  38. #include "io.h.x"
  39. #undef CLASS_DECLARE
  40.  
  41. /* A closed function with a file descriptor as argument */
  42. /* CLASS:
  43.    (class
  44.      (name fd_callback)
  45.      (vars
  46.        (f indirect-method int "int fd")))
  47. */
  48.  
  49. #define FD_CALLBACK(c, fd) ((c)->f(&(c), (fd)))
  50.  
  51. /* Close callbacks are called with a reason as argument. */
  52.  
  53. /* End of file while reading.
  54.  * Or when a closed write_buffer has been flushed successfully. */
  55. /* FIXME: Should we use separate codes for these two events? */
  56. #define CLOSE_EOF 1
  57.  
  58. /* EPIPE when writing */
  59. #define CLOSE_BROKEN_PIPE 2
  60.  
  61. #define CLOSE_WRITE_FAILED 3
  62.  
  63. /* #define CLOSE_READ_FAILED 4 */
  64.  
  65. #define CLOSE_POLL_FAILED 5
  66.  
  67. #define CLOSE_PROTOCOL_FAILURE 6
  68.  
  69. /* CLASS:
  70.    (class
  71.      (name close_callback)
  72.      (vars
  73.        (f method int "int reason")))
  74. */
  75.  
  76. #define CLOSE_CALLBACK(c, r) ((c)->f((c), (r)))
  77.  
  78. /* CLASS:
  79.    (class
  80.      (name nonblocking_fd)
  81.      (super resource)
  82.      (vars
  83.        (next object nonblocking_fd)
  84.        (fd simple int)
  85.        (fname string)
  86.  
  87.        ; User's close callback
  88.        (to_be_closed simple int)
  89.        (close_reason simple int)
  90.        (close_callback object close_callback)
  91.  
  92.        ; Called before poll
  93.        (prepare method void)
  94.  
  95.        (want_read simple int)
  96.        ; Called if poll indicates that data can be read. 
  97.        (read method void)
  98.  
  99.        (want_write simple int)
  100.        ; Called if poll indicates that data can be written.
  101.        (write method void)
  102.  
  103.        ; (close_now simple int)
  104.        (really_close method void)))
  105. */
  106.  
  107. #define PREPARE_FD(fd) ((fd)->prepare((fd)))
  108. #define READ_FD(fd) ((fd)->read((fd)))
  109. #define WRITE_FD(fd) ((fd)->write((fd)))
  110. #define REALLY_CLOSE_FD(fd) ((fd)->really_close((fd)))
  111.  
  112. /* CLASS:
  113.    (class
  114.      (name io_fd)
  115.      (super nonblocking_fd)
  116.      (vars
  117.        (fsync simple int)
  118.        ; Reading 
  119.        (handler object read_handler)
  120.        ; Writing 
  121.        (buffer object abstract_buffer)))
  122. */
  123.  
  124. /* Passed to the listen callback, and to other functions and commands
  125.  * dealing with addresses. */
  126. /* CLASS:
  127.    (class
  128.      (name address_info)
  129.      (vars
  130.        (family simple int)
  131.        (convert2sockaddr method "int" "int" "struct sockaddr *")
  132.        (bind_socket method "int" "int")
  133.        (connect_socket method "int" "int")))
  134. */
  135.  
  136. #define ADDRESS2SOCKADDR(a, s, sa) ((a)->convert2sockaddr(a, s, sa))
  137. #define ADDRESS_BIND(a, f) ((a)->bind_socket)(a, f)
  138. #define ADDRESS_CONNECT(a, f) ((a)->connect_socket(a, f))
  139.  
  140. /* CLASS:
  141.    (class
  142.      (name unix_address_info)
  143.      (super address_info)
  144.      (vars
  145.        (path string)))
  146. */
  147.  
  148. /* CLASS:
  149.    (class
  150.      (name inet_address_info)
  151.      (super address_info)
  152.      (vars
  153.        (ip string)
  154.        (sa simple "struct sockaddr_in")
  155.        (port simple UINT32)))
  156. */
  157.  
  158. /* CLASS:
  159.    (class
  160.      (name fd_listen_callback)
  161.      (vars
  162.        (f method int int "struct address_info *")))
  163. */
  164.  
  165. #define FD_LISTEN_CALLBACK(c, fd, a) ((c)->f((c), (fd), (a)))
  166.  
  167. /* CLASS:
  168.    (class
  169.      (name listen_fd)
  170.      (super nonblocking_fd)
  171.      (vars
  172.        (callback object fd_listen_callback)))
  173. */
  174.  
  175. /* CLASS:
  176.    (class
  177.      (name connect_fd)
  178.      (super nonblocking_fd)
  179.      (vars
  180.        (callback object fd_callback)))
  181. */
  182.  
  183. /* CLASS:
  184.    (class
  185.      (name callback)
  186.      (vars
  187.        (f method void)))
  188. */
  189.  
  190. #define CALLBACK(c) ((c)->f(c))
  191.  
  192. /* CLASS:
  193.    (class
  194.      (name io_backend)
  195.      (vars
  196.        (reloading simple int)
  197.        ; Linked list of fds. 
  198.        (files object nonblocking_fd)
  199.        ; Callouts
  200.        (callouts special-struct "struct ol_queue" do_mark_callouts do_free_callouts)))
  201. */
  202.  
  203. struct callout;
  204.  
  205. void init_backend(struct io_backend *b);
  206.  
  207. int io_iter(struct io_backend *b);
  208. void io_run(struct io_backend *b);
  209.  
  210. int blocking_read(int fd, struct read_handler *r);
  211.  
  212. int get_inaddr(struct sockaddr_in    * addr,
  213.            const char        * host,
  214.            const char        * service,
  215.            const char        * protocol);
  216.  
  217. int tcp_addr(struct sockaddr_in *sin,
  218.          UINT32 length,
  219.          UINT8 *addr,
  220.          UINT32 port);
  221.  
  222. /* int open_inet_socket(int socktype, int proto, struct sockaddr_in *sa); */
  223.  
  224. struct inet_address_info *make_inet_address_c(const char *host,
  225.                                          const char *port);
  226.  
  227. struct inet_address_info *make_inet_address(struct ol_string *host,
  228.                                        UINT32 port);
  229.  
  230. struct unix_address_info *make_unix_address(struct ol_string *path);
  231. struct unix_address_info *make_unix_address_c(const char *path);
  232.  
  233. struct address_info *sockaddr2address_info(size_t addr_len,
  234.                                            struct sockaddr *addr);
  235.  
  236.  
  237. int write_raw(int fd, UINT32 length, UINT8 *data);
  238. int write_raw_with_poll(int fd, UINT32 length, UINT8 *data);
  239.  
  240. void io_set_nonblocking(int fd);
  241. void io_set_close_on_exec(int fd);
  242. void io_init_fd(int fd);
  243.  
  244. int io_open_socket(int family, int socktype, int proto, struct address_info *local);
  245.  
  246. struct connect_fd *io_connect(struct io_backend *b,
  247.                   int fd,
  248.                   struct address_info *remote,
  249.                   struct fd_callback *f);
  250.  
  251.  
  252. struct listen_fd *io_listen(struct io_backend *b,
  253.                 int fd,
  254.                 struct fd_listen_callback *callback);
  255.  
  256.  
  257. struct io_fd *make_io_fd(struct io_backend *backend, int fd,
  258.     struct ol_string *fname);
  259.  
  260. void init_file(struct io_backend *b, struct nonblocking_fd *f, int fd,
  261.     struct ol_string *fname);
  262.  
  263. struct io_fd *io_read_write(struct io_fd *fd,
  264.                 struct read_handler *read_callback,
  265.                 struct abstract_buffer *buffer,
  266.                 struct close_callback *close_callback);
  267.  
  268. struct io_fd *io_read(struct io_fd *fd,
  269.               struct read_handler *read_callback,
  270.               struct close_callback *close_callback);
  271.  
  272. struct io_fd *io_write(struct io_fd *fd,
  273.                struct abstract_buffer *buffer,
  274.                struct close_callback *close_callback);
  275.  
  276. struct callout *io_callout(struct io_backend *backend, time_t timeout, struct callback *callout);
  277. void io_callout_set_timeout(struct callout *co, time_t timeout);
  278. void io_callout_set_drop(struct callout *co, int drop);
  279. void io_callout_flush(struct io_backend *backend);
  280.  
  281. #define closekill_fd(fd, reason) close_fd(fd, reason), kill_fd(fd)
  282.  
  283. int reopen_fd(struct nonblocking_fd *fd);
  284.  
  285. /* Marks a file for close, without touching the close_Reason field. */
  286. void kill_fd(struct nonblocking_fd *fd);
  287.  
  288. void close_fd(struct nonblocking_fd *fd, int reason);
  289.  
  290.  
  291. #endif /* LSH_IO_H_INCLUDED */
  292.